package usecase;
 
import IBO.IIntervention;
import IBO.ITechnicien;
import IBO.IZoneGeographique;
import IUSECASE.IUC_GestionPlanning;
import bo.Intervention;
import bo.ListeInterventions;
import bo.ListeTechniciens;
import bo.Technicien;
import bo.Zone;
import boerrors.AdresseInexistantException;
import boerrors.AdresseMinimumMultiplicityException;
import boerrors.CodePostalMinimumMultiplicityException;
import boerrors.InterventionInexistantException;
import boerrors.RoleMinimumMultiplicityException;
import boerrors.ZoneInexistantException;
import boerrors.ZoneMinimumMultiplicityException;
import java.io.Serializable;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Vector;
import java.util.logging.Level;
import java.util.logging.Logger;
 
public class GestionPlanning implements IUC_GestionPlanning, Serializable {

        private static GestionPlanning instance = null;    
   
        //*******************************************************************    
        //Constructeur du singleton    
        //*******************************************************************        

        public static GestionPlanning getInstance() throws RemoteException {        
                if(instance == null) instance = new GestionPlanning();        
                return instance;    
        }
   
        public GestionPlanning() throws RemoteException {
                super();
                UnicastRemoteObject.exportObject(this, 0);
        } 
   
        //*******************************************************************
        //Convertir une liste d'Intervention en liste d'IIntervention
        //*******************************************************************
        
        private Vector<IIntervention> convertLstIntToLstIInt(Vector<Intervention> liste) {
                Vector<IIntervention> listeTampon = new Vector<IIntervention>();
                for (int i = 0; i < liste.size(); i++) listeTampon.add((IIntervention)liste.get(i));
                return listeTampon;
        }
        
        private Vector<Intervention> convertLstIIntToLstInt(Vector<IIntervention> liste) {
                Vector<Intervention> listeTampon = new Vector<Intervention>();
                for (int i = 0; i < liste.size(); i++) listeTampon.add((Intervention)liste.get(i));
                return listeTampon;
        }
        
        //Technicien
        private Vector<ITechnicien> convertTechtoITech(Vector<Technicien> liste) {
                Vector<ITechnicien> lstTmp = new Vector<ITechnicien>();
                for (int i = 0; i < liste.size(); i++){
                    liste.get(i).getNom();
                    lstTmp.add((ITechnicien) liste.get(i));}
                return lstTmp;
        }

        //*******************************************************************    
        //Methodes heritees    
        //******************************************************************* 

        public Vector<IZoneGeographique> listerZone() throws RemoteException{
                try {
                    return bo.Zone.lister();
                } catch (ZoneInexistantException ex) {
                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                    return null;
                }
        }        
        
        public Vector<IIntervention> listeInterventionPlanifiee() throws RemoteException{
                Vector<IIntervention> listeTampon = convertLstIntToLstIInt(bo.ListeInterventions.getInstance().listeInterventionPlanifiee());
                System.out.println("==============[PLANNIFIEE]====================");
                for (int i = 0 ; i < listeTampon.size(); i++)
                    System.out.println(listeTampon.get(i).getIdIntervention() + listeTampon.get(i).getPrioriteIntervention());
                System.out.println("==============================================");
                return listeTampon;
        }

        public Vector<IIntervention> listeInterventionAPlanifier() throws RemoteException{
                Vector<IIntervention> listeTampon = convertLstIntToLstIInt(bo.ListeInterventions.getInstance().listeInterventionAPlanifier());
                System.out.println("==============[APLANNIFIEE]====================");
                for (int i = 0 ; i < listeTampon.size(); i++)
                    System.out.println(listeTampon.get(i).getIdIntervention() + listeTampon.get(i).getPrioriteDemande());
                System.out.println("==============================================");                
                return listeTampon;
        }
    
        public Vector<IIntervention> listeInterventionAReplanifier() throws RemoteException {
                Vector<IIntervention> listeTampon = convertLstIntToLstIInt(bo.ListeInterventions.getInstance().listeInterventionDeplanifiee());
                System.out.println("==============[REPLANNIFIEE]====================");
                for (int i = 0 ; i < listeTampon.size(); i++)
                    System.out.println(listeTampon.get(i).getIdIntervention() + listeTampon.get(i).getPrioriteIntervention());
                System.out.println("==============================================");
                return listeTampon;
        }

        public Vector<IIntervention> listeInterventionEnCours() throws RemoteException {
                Vector<IIntervention> listeTampon = convertLstIntToLstIInt(bo.ListeInterventions.getInstance().listeInterventionEnCours());
                return listeTampon;
        }

        public Vector<IIntervention> listeInterventionHistorique() throws RemoteException {
                try {
                    Vector<IIntervention> listeTampon = convertLstIntToLstIInt(Intervention.listeInterventionHistorique());
                    return listeTampon;
                } catch (InterventionInexistantException ex) {
                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                    return null;
                }
        }

        public Vector<IIntervention> listeInterventionSuivies() throws RemoteException {
                try {
                    Vector<IIntervention> listeTampon = convertLstIntToLstIInt(Intervention.listeInterventionSuivies());
                    return listeTampon;
                } catch (InterventionInexistantException ex) {
                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                return null;
                }
        }        
        
        public Vector<IIntervention> listeInterventionCloturees() throws RemoteException {
                try {
                    Vector<IIntervention> listeTampon = convertLstIntToLstIInt(Intervention.listeInterventionCloturees());
                    return listeTampon;
                } catch (InterventionInexistantException ex) {
                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                return null;
                }
        }        
        
        public Vector<IIntervention> listeInterventionAnnulees() throws RemoteException {
                try {
                    Vector<IIntervention> listeTampon = convertLstIntToLstIInt(Intervention.listeInterventionAnnulees());
                    return listeTampon;
                } catch (InterventionInexistantException ex) {
                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                return null;
                }
        }        

        public Vector<ITechnicien> listerTechniciens(String zone, GregorianCalendar dateIntervention) throws RemoteException {
                int nbIntervention;
                Vector<Intervention> listeIntervention = new Vector<Intervention>();
                Vector<ITechnicien> listeITechnicien = new Vector<ITechnicien>();
                Vector<ITechnicien> listeTechnicien = convertTechtoITech(bo.ListeTechniciens.getInstance().getListeTechnicien());
                DateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy");
                Date tampon = dateIntervention.getTime();
                String dateFormatee = dateFormat.format(tampon); 
                //On recupere les techniciens 
                for (int i=0; i < listeTechnicien.size() ; i++) {
                    try {
                        //Pour chaque technicien de la zone
                        if (((ITechnicien) listeTechnicien.get(i)).getIZone().getLibelleZone().compareTo(zone) == 0){ 
                            //On recupere la liste des interventions de chaque technicien
                            listeIntervention = convertLstIIntToLstInt(((ITechnicien) listeTechnicien.get(i)).getListeIInterventions());
                            //nbIntervention = nb d'interventions deja planifiees
                            //nbIntervention = 0;
                            //for (int j = 0; j < listeIntervention.size(); j++) {
                            //    if (listeIntervention.get(j).getDateIntervention().equals(dateIntervention)) 
                            //    nbIntervention++;
                            //}
                            //Si le tchnicien est libre, on l'ajoute dans la liste
                            //if (nbIntervention < 4) listeITechnicien.add(listeTechnicien.get(i));
                            listeITechnicien.add(listeTechnicien.get(i));
                        }
                    } catch (ZoneMinimumMultiplicityException ex) {
                        Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                    }
                }
                return listeITechnicien; 
        }

        public void planifier(  IIntervention intervention, ITechnicien technicien, GregorianCalendar dateIntervention, 
                                String prioriteIntervention) throws RemoteException {
                try {
                    Technicien technicienTampon = ListeTechniciens.getInstance().rechercherEmploye(technicien.getMatricule());
                    Intervention interventionTampon = ListeInterventions.getInstance().rechercherIntervention(intervention.getIdIntervention());
                    interventionTampon.planifier(technicienTampon, dateIntervention, prioriteIntervention);
                    bo.ListeInterventions.getInstance().notifyAllSubscibers();
                } catch (InterventionInexistantException ex) {
                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                } catch (AdresseInexistantException ex) {
                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                } catch (AdresseMinimumMultiplicityException ex) {
                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                } catch (CodePostalMinimumMultiplicityException ex) {
                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                } catch (ZoneMinimumMultiplicityException ex) {
                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                } catch (RoleMinimumMultiplicityException ex) {
                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                }
        }
    
        public void replanifier(IIntervention intervention, ITechnicien technicien, GregorianCalendar dateIntervention) throws RemoteException {
                try {
                    Technicien technicienTampon = ListeTechniciens.getInstance().rechercherEmploye(technicien.getMatricule());
                    Intervention interventionTampon = ListeInterventions.getInstance().rechercherIntervention(intervention.getIdIntervention());
                    interventionTampon.replanifier(technicienTampon, dateIntervention);
                    bo.ListeInterventions.getInstance().notifyAllSubscibers();
                } catch (InterventionInexistantException ex) {
                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                } catch (AdresseInexistantException ex) {
                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                } catch (AdresseMinimumMultiplicityException ex) {
                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                } catch (CodePostalMinimumMultiplicityException ex) {
                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                } catch (ZoneMinimumMultiplicityException ex) {
                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                } catch (RoleMinimumMultiplicityException ex) {
                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                }
        }
    
        public void deplanifier(IIntervention intervention) throws RemoteException {
                try {
                    Intervention interventionTampon = ListeInterventions.getInstance().rechercherIntervention(intervention.getIdIntervention());
                    interventionTampon.deplanifier();
                    bo.ListeInterventions.getInstance().notifyAllSubscibers();
                } catch (InterventionInexistantException ex) {
                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                } catch (AdresseInexistantException ex) {
                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                } catch (CodePostalMinimumMultiplicityException ex) {
                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                } catch (ZoneMinimumMultiplicityException ex) {
                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                }
        }

//        public void annuler(IIntervention intervention) throws RemoteException {
//                try {
//                    Intervention interventionTampon = ListeInterventions.getInstance().rechercherIntervention(intervention.getIdIntervention());
//                    interventionTampon.annuler();
//                    if(((Intervention)intervention).getStatut().getlibelle().compareTo("CR") == 0)
//                        listeInterventionAPlanifier().remove(intervention);
//                    else if(((Intervention)intervention).getStatut().getlibelle().compareTo("PL") == 0)
//                        listeInterventionPlanifiee().remove(intervention);
//                    else if(((Intervention)intervention).getStatut().getlibelle().compareTo("DE") == 0)
//                        listeInterventionAReplanifier().remove(intervention);
//                    else if(((Intervention)intervention).getStatut().getlibelle().compareTo("EN") == 0)
//                        listeInterventionEnCours().remove(intervention);
//                } catch (InterventionInexistantException ex) {
//                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
//                } catch (AdresseInexistantException ex) {
//                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
//                } catch (CodePostalMinimumMultiplicityException ex) {
//                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
//                } catch (ZoneMinimumMultiplicityException ex) {
//                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
//                }
//        }

        public void annuler(int idIntervention) throws RemoteException {
                try {
                    Intervention intervention = ListeInterventions.getInstance().rechercherIntervention(idIntervention);
                    Intervention interventionTampon = ListeInterventions.getInstance().rechercherIntervention(idIntervention);
                    interventionTampon.annuler();
                    if(((Intervention)intervention).getStatut().getlibelle().compareTo("CR") == 0)
                        //listeInterventionAPlanifier().remove(intervention);
                        bo.ListeInterventions.getInstance().supprimerIntervention(intervention);
                    else if(((Intervention)intervention).getStatut().getlibelle().compareTo("PL") == 0)
                        //listeInterventionPlanifiee().remove(intervention);
                        bo.ListeInterventions.getInstance().supprimerIntervention(intervention);
                    else if(((Intervention)intervention).getStatut().getlibelle().compareTo("DE") == 0)
                        //listeInterventionAReplanifier().remove(intervention);
                        bo.ListeInterventions.getInstance().supprimerIntervention(intervention);
                    else if(((Intervention)intervention).getStatut().getlibelle().compareTo("EN") == 0)
                        //listeInterventionEnCours().remove(intervention);
                        bo.ListeInterventions.getInstance().supprimerIntervention(intervention);
                } catch (InterventionInexistantException ex) {
                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                } catch (AdresseInexistantException ex) {
                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                } catch (CodePostalMinimumMultiplicityException ex) {
                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                } catch (ZoneMinimumMultiplicityException ex) {
                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                }
        }        
        

        private Vector<ITechnicien> convTechtoITech(Vector<Technicien> liste) throws RemoteException {
                Vector<ITechnicien> lstTmp = new Vector<ITechnicien>();
                for (int i = 0; i < liste.size(); i++){
                    liste.get(i).getNom();
                    lstTmp.add((ITechnicien) liste.get(i));}
                return lstTmp;
        }        
        
        public Vector<ITechnicien> getPlanningTechniciens(int filtreIntervention, String zone ,Date dateDebut) throws RemoteException, ZoneMinimumMultiplicityException{
                Vector<ITechnicien> listeITechnicien = new Vector<ITechnicien>();
                Vector<Technicien> lstTmpTechnicien = bo.ListeTechniciens.getInstance().getListeTechnicien();
                //Vector<ITechnicien> lstTmpTechnicien2 = (Vector<ITechnicien>) (ITechnicien) lstTmpTechnicien.clone();
                //System.out.println(lstTmpTechnicien2.get(1).getEmail());
                switch(filtreIntervention){
                    case 0: //Aucune intervention
//                            //On liste les techniciens
                            for (int i = 0; i < lstTmpTechnicien.size(); i++){
                                try {
                                    if (getNbrInterventionTech_Date(lstTmpTechnicien.get(i), dateDebut, zone) == 0) {
                                        Vector<Intervention> lstTampon = retrieveInterventions(lstTmpTechnicien.get(i), dateDebut, zone);
                                        Technicien technicien = (Technicien) lstTmpTechnicien.get(i).clone();
                                        technicien.setListeInterventions(lstTampon);
                                        ITechnicien itechnicien =(ITechnicien) UnicastRemoteObject.exportObject(technicien, 0);
     
                                        listeITechnicien.add(itechnicien);
                                    }
                                } catch (AdresseInexistantException ex) {
                                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                                } catch (CodePostalMinimumMultiplicityException ex) {
                                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                                }
                            }

                        break;
                    case 1: //1 intervention
                        System.out.println("DEBUG: 1 intervention");
                            for (int i = 0; i < lstTmpTechnicien.size(); i++){
                                try {
                                    if (getNbrInterventionTech_Date(lstTmpTechnicien.get(i), dateDebut, zone) == 1) {
                                        Vector<Intervention> lstTampon = retrieveInterventions(lstTmpTechnicien.get(i), dateDebut, zone);
                                        Technicien technicien = (Technicien) lstTmpTechnicien.get(i).clone();
                                        technicien.setListeInterventions(lstTampon);
                                        ITechnicien itechnicien =(ITechnicien) UnicastRemoteObject.exportObject(technicien, 0);
     
                                        listeITechnicien.add(itechnicien);
                                    }
                                } catch (AdresseInexistantException ex) {
                                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                                } catch (CodePostalMinimumMultiplicityException ex) {
                                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                                }
                            }
                        break;
                    case 2: //2 interventions
                            for (int i = 0; i < lstTmpTechnicien.size(); i++){
                                try {
                                    if (getNbrInterventionTech_Date(lstTmpTechnicien.get(i), dateDebut, zone) == 2) {
                                        Vector<Intervention> lstTampon = retrieveInterventions(lstTmpTechnicien.get(i), dateDebut, zone);
                                        Technicien technicien = (Technicien) lstTmpTechnicien.get(i).clone();
                                        technicien.setListeInterventions(lstTampon);
                                        ITechnicien itechnicien =(ITechnicien) UnicastRemoteObject.exportObject(technicien, 0);
     
                                        listeITechnicien.add(itechnicien);
                                    }
                                } catch (AdresseInexistantException ex) {
                                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                                } catch (CodePostalMinimumMultiplicityException ex) {
                                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                                }
                            }                        
                        break;
                    case 3: //3 interventions
                            for (int i = 0; i < lstTmpTechnicien.size(); i++){
                                try {
                                    if (getNbrInterventionTech_Date(lstTmpTechnicien.get(i), dateDebut, zone) == 3) {
                                        Vector<Intervention> lstTampon = retrieveInterventions(lstTmpTechnicien.get(i), dateDebut, zone);
                                        Technicien technicien = (Technicien) lstTmpTechnicien.get(i).clone();
                                        technicien.setListeInterventions(lstTampon);
                                        ITechnicien itechnicien =(ITechnicien) UnicastRemoteObject.exportObject(technicien, 0);
     
                                        listeITechnicien.add(itechnicien);
                                    }
                                } catch (AdresseInexistantException ex) {
                                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                                } catch (CodePostalMinimumMultiplicityException ex) {
                                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                                }
                            }                        
                        break;
                    case 4: //4 interventions
                            for (int i = 0; i < lstTmpTechnicien.size(); i++){
                                try {
                                    if (getNbrInterventionTech_Date(lstTmpTechnicien.get(i), dateDebut, zone) == 4) {
                                        Vector<Intervention> lstTampon = retrieveInterventions(lstTmpTechnicien.get(i), dateDebut, zone);
                                        Technicien technicien = (Technicien) lstTmpTechnicien.get(i).clone();
                                        technicien.setListeInterventions(lstTampon);
                                        ITechnicien itechnicien =(ITechnicien) UnicastRemoteObject.exportObject(technicien, 0);
     
                                        listeITechnicien.add(itechnicien);
                                    }
                                } catch (AdresseInexistantException ex) {
                                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                                } catch (CodePostalMinimumMultiplicityException ex) {
                                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                                }
                            }                        
                        break;
                    case 5: //Plus de 4 interventions
                            for (int i = 0; i < lstTmpTechnicien.size(); i++){
                                try {
                                    if (getNbrInterventionTech_Date(lstTmpTechnicien.get(i), dateDebut, zone) > 4) {
                                        Vector<Intervention> lstTampon = retrieveInterventions(lstTmpTechnicien.get(i), dateDebut, zone);
                                        Technicien technicien = (Technicien) lstTmpTechnicien.get(i).clone();
                                        technicien.setListeInterventions(lstTampon);
                                        ITechnicien itechnicien =(ITechnicien) UnicastRemoteObject.exportObject(technicien, 0);
     
                                        listeITechnicien.add(itechnicien);
                                    }
                                } catch (AdresseInexistantException ex) {
                                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                                } catch (CodePostalMinimumMultiplicityException ex) {
                                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                                }
                            }                        
                        break;
                    case 6: //Moins de 4 interventions
                            for (int i = 0; i < lstTmpTechnicien.size(); i++){
                                try {
                                    if (getNbrInterventionTech_Date(lstTmpTechnicien.get(i), dateDebut, zone) < 4) {
                                        Vector<Intervention> lstTampon = retrieveInterventions(lstTmpTechnicien.get(i), dateDebut, zone);
                                        Technicien technicien = (Technicien) lstTmpTechnicien.get(i).clone();
                                        technicien.setListeInterventions(lstTampon);
                                        ITechnicien itechnicien =(ITechnicien) UnicastRemoteObject.exportObject(technicien, 0);
     
                                        listeITechnicien.add(itechnicien);
                                    }
                                } catch (AdresseInexistantException ex) {
                                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                                } catch (CodePostalMinimumMultiplicityException ex) {
                                    Logger.getLogger(GestionPlanning.class.getName()).log(Level.SEVERE, null, ex);
                                }
                            }                        
                        break;
                }
                System.out.println("DEBUG: listeTechnicien: " + listeITechnicien.size());
                Vector<ITechnicien> lstTmp = new Vector<ITechnicien>();
                for (int i = 0; i < listeITechnicien.size(); i++){
                    listeITechnicien.get(i).getNom();
                    ITechnicien stechnicien = (ITechnicien) listeITechnicien.get(i);
                    lstTmp.add(stechnicien);}
                return lstTmp;

        }
        
        //Retourne le nombre d'interventions d'un technicien à une date précise pour une zone ou toutes.
        private int getNbrInterventionTech_Date(ITechnicien technicien, Date date, String zone) throws RemoteException, AdresseInexistantException, CodePostalMinimumMultiplicityException, ZoneMinimumMultiplicityException{
            int nbrIntervention = 0;
            for(int i = 0; i < technicien.getListeIInterventions().size(); i++){
                if((technicien.getListeIInterventions().get(i).getDateIntervention().getTime().compareTo(date) == 0)){
                    if (zone != null){
                        if(technicien.getListeIInterventions().get(i).getIAdresse().getICodePostal().getZone().getLibelleZone().compareTo(zone) == 0){
                            nbrIntervention ++; 
                        }
                    }else{
                        nbrIntervention ++;
                    }
                }
            }
            System.out.println("DEBUG: Nbr Intervention filtre " + nbrIntervention);
            return nbrIntervention;
        }
        
        
        //retourne les interventions d'un technicien à une date précise
        private Vector<Intervention> retrieveInterventions(Technicien technicien, Date date, String zone) throws RemoteException, AdresseInexistantException, CodePostalMinimumMultiplicityException, ZoneMinimumMultiplicityException{
            Vector<Intervention> lstInterventions = new Vector<Intervention>();
            for(int i = 0; i < technicien.getListeIInterventions().size(); i++){
                if((technicien.getListeIInterventions().get(i).getDateIntervention().getTime().compareTo(date) == 0)){
                    if (zone != null){
                        if(technicien.getListeInterventions().get(i).getIAdresse().getICodePostal().getZone().getLibelleZone().compareTo(zone) == 0){
                            Intervention intervention = technicien.getListeInterventions().get(i);//(IIntervention) UnicastRemoteObject.exportObject(technicien.getListeIInterventions().get(i), 0); 
                            lstInterventions.add(intervention);
                            //lstInterventions.add(technicien.getListeIInterventions().get(i));
                        }
                    }else{
                        lstInterventions.add(technicien.getListeInterventions().get(i));
                    }
                }
            }
            System.out.println("DEBUG:Liste intervention Nbr Interventions filtre " + lstInterventions.size());
            return lstInterventions;
        }
        
        
}